In conventional client-server systems, queries to a database typically involve a request that is transmitted from a client to a server equipped with a database. In response to such request, various data in the database may be transmitted from the server to the client. Such queries are typically carried out utilizing a structured query language (SQL), which constitutes a language that provides an interface to the database.
In modern database systems, various relationships may exist between data entities (e.g. accounts, contacts, other objects, etc., in the database. For example, one particular account may have relationships with other entities that include a large number of related contacts.
Unfortunately, in conventional approaches, such related data must be queried separately. For example, if a client desired to obtain data associated with the particular account in addition to the related contacts, a first query would be required to retrieve the data associated with the account and a second query would be required to obtain the data associated with the related contacts. Further, the client would have to be configured to combine the data associated with such entities after receipt.
Thus, in traditional approaches, a large number of queries may be required to obtain data on related entities. Such additional queries can be problematic, particularly when communicating large amounts of data over a certain network architectures or topologies, such as for example, a wide area network (WAN), because of the possibility of latent behavior of the network (i.e. delays due to asynchronous operation, etc. For example, if there is a particular latency associated with one query over a network, such latency is compounded by the foregoing use of multiple queries (each with their own latency).
There is thus a need for overcoming these and/or other problems associated with the prior art.